home *** CD-ROM | disk | FTP | other *** search
/ Freelog Special Edition 10 / FreelogHS10.iso / Buzz / Buzz_Advanced_Pack.exe / {app} / Dev / elenzil_modulator.cpp < prev    next >
C/C++ Source or Header  |  2001-08-27  |  17KB  |  816 lines
  1. /*
  2.  
  3.   The Elenzil Amplitude Modulator    1.0
  4.  
  5.   20010303 Santa Cruz California
  6.  
  7.   This machine was written primarily because Goenik's Amplitude Modulator
  8.   introduces small but noticable artifacts in the sound.  For instance,
  9.   try tunning the M4 in the included demo song thru a single Goenik's
  10.   and compare to a single Elenzil. You may need to listen with headphones.
  11.  
  12.   Since i used the AM far more than any other single effect,
  13.   i finally got tired of fixing the artifacts up in cooledit,
  14.   and went to write my own.
  15.  
  16.   My guess at the cause of goenik's artifacts is that he calculated
  17.   the stereo spread only once per Work() routine, rather than for each Sample.
  18.   My version does it for each sample. This is probably overkill, but it works for me.
  19.   
  20.  
  21.   !!!
  22.   This machine is Crap for Efficiency.
  23.   I don't really care, as i usually have fast computers.
  24.   --> I am using actual Sin() calls, not lookup tables!
  25.   There is no justification for this except my own laziness.
  26.  
  27.   Also, i built this off of an example from the standard buzz dist,
  28.   and havn't cleaned anything up.
  29.  
  30.   If you fix it up, god bless you.
  31.  
  32.   Okay,
  33.   that's about it.
  34.   Compiled w/ VC6.
  35.  
  36.   Orion Elenzil
  37.   www.elenzil.com
  38.  
  39.  
  40.   */
  41.  
  42.  
  43.  
  44. #include <stdio.h>
  45. #include <string.h>
  46. #include <stdlib.h>
  47. #include <assert.h>
  48. #include <math.h>
  49. #include "../MachineInterface.h"
  50. #include "../dsplib/dsplib.h"
  51. #include <time.h>
  52.  
  53. double const SilentEnough = log(1.0 / 32768);
  54.  
  55. #define MAX_TAPS        1
  56.  
  57. CMachineParameter const paraSpeed = 
  58. { 
  59.     pt_word,                                        // type
  60.     "Speed",
  61.     "Oscillation Speed",                            // description
  62.     0,                                                // MinValue    
  63.     65534,                                            // MaxValue
  64.     65535,                                            // NoValue
  65.     MPF_STATE,                                        // Flags
  66.     1000                                            // Default
  67. };
  68.  
  69. #define UNIT_MHZ    0
  70. #define UNIT_MS        1
  71. #define UNIT_TICK    2
  72. #define UNIT_256    3
  73.  
  74.  
  75. CMachineParameter const paraUnit =
  76. { 
  77.     pt_byte,                                         // type
  78.     "Speed Unit",
  79.     "Speed unit (0 = mHz, 1 = ms, 2 = tick, 3 = 256th of tick)",        
  80.     0,                                                // MinValue    
  81.     3,                                                // MaxValue
  82.     0xff,                                            // NoValue
  83.     MPF_STATE,                                        // Flags
  84.     UNIT_MHZ                                        // Default
  85. };
  86.  
  87. #define    WAVE_SIN        0
  88. #define    WAVE_SQUARE        1
  89. #define    WAVE_TRIANGLE    2
  90. #define    WAVE_SAW        3
  91. #define    WAVE_INVSAW        4
  92. #define    WAVE_CRAZY        5
  93.  
  94.  
  95. CMachineParameter const paraWave =
  96. { 
  97.     pt_byte,                                         // type
  98.     "Wave Type",
  99.     "Wave Type (0 = sin, 1 = square, 2 = triangle 3 = saw, 4 = inv. saw)",
  100.     0,                                                // MinValue    
  101.     4,                                                // MaxValue
  102.     0xff,                                            // NoValue
  103.     MPF_STATE,                                        // Flags
  104.     WAVE_SIN,                                        // Default
  105. };
  106.  
  107. CMachineParameter const paraWavePow =
  108. { 
  109.     pt_byte,                                         // type
  110.     "Wave Power",
  111.     "Wave Power (1 = 1, 2 = ^2, 3 = ^3 etc)",
  112.     1,                                                // MinValue    
  113.     13,                                                // MaxValue
  114.     0xff,                                            // NoValue
  115.     MPF_STATE,                                        // Flags
  116.     1,                                                // Default
  117. };
  118.  
  119. CMachineParameter const paraFloor =
  120. { 
  121.     pt_byte,                                         // type
  122.     "Floor",
  123.     "Floor 00 - fe",
  124.     0,                                                // MinValue    
  125.     0xfe,                                            // MaxValue
  126.     0xff,                                            // NoValue
  127.     MPF_STATE,                                        // Flags
  128.     0                                                // Default
  129. };
  130.  
  131. CMachineParameter const paraSpread =
  132. { 
  133.     pt_word,                                         // type
  134.     "Phase",
  135.     "Phase x0000 - x0800",
  136.     0x0000,                                            // MinValue    
  137.     0x0800,                                            // MaxValue
  138.     0xffff,                                            // NoValue
  139.     MPF_STATE,                                        // Flags
  140.     0x0800,                                            // Default
  141. };
  142.  
  143. CMachineParameter const paraSlur =
  144. { 
  145.     pt_byte,                                         // type
  146.     "Slur",
  147.     "Slur x00 - xfe",
  148.     0x00,                                            // MinValue    
  149.     0xfe,                                            // MaxValue
  150.     0xff,                                            // NoValue
  151.     MPF_STATE,                                        // Flags
  152.     0xf2,                                            // Default
  153. };
  154.  
  155. CMachineParameter const paraGain =
  156. { 
  157.     pt_byte,                                         // type
  158.     "Gain",
  159.     "Gain x00 - xfe",
  160.     0x00,                                            // MinValue    
  161.     0xf0,                                            // MaxValue
  162.     0xff,                                            // NoValue
  163.     MPF_STATE,                                        // Flags
  164.     0x12,                                            // Default
  165. };
  166.  
  167. CMachineParameter const paraReset =
  168. { 
  169.     pt_switch,                                         // type
  170.     "Reset",
  171.     "Reset 1 = Restart Oscillator",
  172.     0x01,                                            // MinValue    
  173.     0x01,                                            // MaxValue
  174.     0xff,                                            // NoValue
  175.     MPF_TICK_ON_EDIT,                                // Flags
  176.     0xff,                                            // Default
  177. };
  178.  
  179. CMachineParameter const *pParameters[] = 
  180. { 
  181.     ¶Speed,
  182.     ¶Unit,
  183.     ¶Wave,
  184.     ¶WavePow,
  185.     ¶Floor,
  186.     ¶Spread,
  187.     ¶Slur,
  188.     ¶Gain,
  189.     ¶Reset,
  190. };
  191.  
  192. #pragma pack(1)
  193.  
  194. class tvals
  195. {
  196. public:
  197.     word    speed;
  198.     byte    unit;
  199.     byte    wave;
  200.     byte    wavepow;
  201.     byte    floor;
  202.     word    spread;
  203.     byte    slur;
  204.     byte    gain;
  205.     byte    reset;
  206. };
  207.  
  208.  
  209. #pragma pack()
  210.  
  211. CMachineInfo const MacInfo = 
  212. {
  213.     MT_EFFECT,                                // type
  214.     MI_VERSION,
  215.     MIF_MONO_TO_STEREO,                        // flags
  216.     1,                                        // min tracks
  217.     1,                                        // max tracks
  218.     0,                                        // numGlobalParameters
  219.     9,                                        // numTrackParameters
  220.     pParameters,
  221.     0,
  222.     NULL,
  223. #ifdef _DEBUG
  224.     "Elenzil Amplitude Modulator (Debug)",    // name
  225. #else
  226.     "Elenzil Amplitude Modulator",
  227. #endif
  228.     "Modulator",                            // short name
  229.     "www.elenzil.com",                        // author
  230.     NULL
  231. };
  232.  
  233. class CTrack
  234. {
  235.     public:
  236.     double    Speed;
  237.     int        Unit;
  238.     int        Wave;
  239.     int        WavePow;
  240.     int        Floor;
  241.     double    Spread;
  242.     double    Slur;
  243.     double    Gain;
  244.     bool    Reset;
  245.  
  246.     double    GetFrequency(CMasterInfo* pMasterInfo);
  247. };
  248.  
  249.  
  250. // Return frequency in seconds.
  251. inline    double    CTrack::GetFrequency(CMasterInfo* pMasterInfo)
  252.     {
  253.     switch (Unit)
  254.         {
  255.         default:
  256.         case    UNIT_MHZ:
  257.             return Speed * 0.001;
  258.             break;
  259.         case    UNIT_MS:
  260.             if (Speed != 0.0)
  261.                 return 1000.0 / Speed;
  262.             else
  263.                 return 1000.0 / 0.5;
  264.             break;
  265.         case    UNIT_TICK:
  266.             if (Speed != 0.0)
  267.                 return pMasterInfo -> TicksPerSec / Speed;
  268.             else
  269.                 return pMasterInfo -> TicksPerSec;
  270.             break;
  271.         case    UNIT_256:
  272.             if (Speed != 0.0)
  273.                 return 256.0 * pMasterInfo -> TicksPerSec / Speed;
  274.             else
  275.                 return 256.0 * pMasterInfo -> TicksPerSec;
  276.             break;
  277.         }
  278.     }
  279.  
  280. class mi : public CMachineInterface
  281. {
  282. public:
  283.     mi();
  284.     virtual ~mi();
  285.  
  286.     virtual void Init(CMachineDataInput * const pi);
  287.     virtual void Tick();
  288. //    virtual bool Work(float *psamples, int numsamples, int const mode);
  289.     virtual bool WorkMonoToStereo(float *pin, float *pout, int numsamples, int const mode);
  290.  
  291.     virtual void SetNumTracks(int const n);
  292.  
  293.     virtual void AttributesChanged();
  294.  
  295.     virtual char const *DescribeValue(int const param, int const value);
  296.  
  297. private:
  298.     void    InitTrack(int const i);
  299.     void    ResetTrack(int const i);
  300.  
  301.     void    TickTrack(CTrack *pt, tvals *ptval);
  302.     void    WorkTrack(CTrack *pt, float *pin, float *pout, int numsamples, int const mode);
  303.     int        MSToSamples(double const ms);
  304.  
  305. private:
  306.     int        IdleCount;    // in samples
  307.     bool    IdleMode;
  308.     int        pos;
  309.     int        pos2;
  310.  
  311.     long    m_Tick;
  312.     double    m_Second;
  313.     double    m_PrevF1;
  314.     double    m_PrevF2;
  315.  
  316. private:
  317.     int numTracks;
  318.     CTrack Tracks[MAX_TAPS];
  319.  
  320.     tvals tval[MAX_TAPS];
  321.  
  322.  
  323. };
  324.  
  325. DLL_EXPORTS
  326.  
  327. mi::mi()
  328. {
  329.     GlobalVals    = NULL;
  330.     TrackVals    = tval;
  331.     AttrVals    = NULL;
  332. }
  333.  
  334. mi::~mi()
  335. {
  336. }
  337.  
  338. char*    CommaPrint(char* txt, int const value)
  339.     {
  340.     char    tmp[32];
  341.     int        i, inum;
  342.     int        j, k;
  343.     sprintf(tmp, "%d", value);
  344.     inum    =    strlen(tmp);
  345.     j        =    inum    % 3;
  346.     k        =    0;
  347.     for (i = 0; i < inum; i++)
  348.         {
  349.         txt[k++] = tmp[i];
  350.         j--;
  351.         if (j == 0 && i < inum - 1)
  352.             {
  353.             txt[k++] = ',';
  354.             j = 3;
  355.             }
  356.         }
  357.     txt[k] = 0;
  358.  
  359.     return txt;
  360.     }
  361.  
  362. char const *mi::DescribeValue(int const param, int const value)
  363. {
  364.     static char txt[16];
  365.     char    tmp[9];
  366.     int        val;
  367.  
  368.     val    =    value;
  369.  
  370.     switch(param)
  371.     {
  372.     case 0:        // freq
  373.         switch(Tracks[0].Unit)
  374.             {
  375.             default:
  376.             case    UNIT_MS:
  377.             case    UNIT_MHZ:
  378.                 CommaPrint(txt, val);
  379.                 sprintf(tmp, " (%.4x)", val);
  380.                 strcat(txt, tmp);
  381.                 break;
  382.             }
  383.         break;
  384.     case 1:        // unit
  385.         switch(val)
  386.             {
  387.             case 0: return "mHz (00)";
  388.             case 1: return "ms (01)";
  389.             case 2: return "tick (02)";
  390.             case 3: return "tick/256 (03)";
  391.             }
  392.         break;
  393.     case 2:        // wave
  394.         char*    s;
  395.         switch(val)
  396.             {
  397.             case WAVE_SIN        : s = "sin"            ; break;
  398.             case WAVE_SQUARE    : s = "square"        ; break;
  399.             case WAVE_TRIANGLE    : s = "triangle"    ; break;
  400.             case WAVE_SAW        : s = "saw"            ; break;
  401.             case WAVE_INVSAW    : s = "inv. saw"    ; break;
  402.             case WAVE_CRAZY        : s = "crazy"        ; break;
  403.             }
  404.             sprintf(txt, "%s (%.2x)", s, val);
  405.         break;
  406.     case 3:        // wave power
  407.         sprintf(txt, "^%d", val);
  408.         break;
  409.     case 4:        // floor
  410.         sprintf(txt, "%d%c (%.2x)", val * 100 / paraFloor.MaxValue, '%', val);
  411.         break;
  412.     case 5:        // spread
  413.         sprintf(txt, "%.3f (%.4x)", (double)val / (double)paraSpread.MaxValue * 2.0 - 1.0, val);
  414.         break;
  415.     case 6:        // slur
  416.         sprintf(txt, "%.3f (%.2x)", (double)val / (double)paraSlur.MaxValue, val);
  417.         break;
  418.     case 7:        // gain
  419.         sprintf(txt, "%.2f (%.2x)", (double)val / (double)paraGain.DefValue, val);
  420.         break;
  421.     case 8:        // reset
  422.         sprintf(txt, "1 = reset oscillation");
  423.         break;
  424.     default:
  425.         return NULL;
  426.     }
  427.  
  428.     return txt;
  429. }
  430.  
  431.  
  432.  
  433. void mi::Init(CMachineDataInput * const pi)
  434. {
  435.     numTracks = 1;
  436.  
  437.     for (int c = 0; c < MAX_TAPS; c++)
  438.     {
  439.         Tracks[c].Speed        = 1000.0;
  440.         Tracks[c].Unit        = UNIT_MHZ;
  441.         Tracks[c].Wave        = WAVE_SIN;
  442.         Tracks[c].WavePow    = 1;
  443.         Tracks[c].Floor        = 0;
  444.         Tracks[c].Spread    = 1.0;
  445.         Tracks[c].Slur        = 0.94;
  446.         Tracks[c].Gain        = 1.0;
  447.         Tracks[c].Reset        = false;
  448.     }
  449.  
  450.     IdleMode    =    true;
  451.     IdleCount    =    0;
  452.     pos            =    0;
  453.     pos2        =    0;
  454.     
  455.     m_Tick        =    0;
  456.     m_Second    =    0.0;
  457.  
  458.     m_PrevF1    =    1.0;
  459.     m_PrevF2    =    1.0;
  460. }
  461.  
  462. void mi::AttributesChanged()
  463. {
  464.     for (int c = 0; c < numTracks; c++)
  465.         InitTrack(c);
  466. }
  467.  
  468.  
  469. void mi::SetNumTracks(int const n)
  470. {
  471.     if (numTracks < n)
  472.     {
  473.         for (int c = numTracks; c < n; c++)
  474.             InitTrack(c);
  475.     }
  476.     else if (n < numTracks)
  477.     {
  478.         for (int c = n; c < numTracks; c++)
  479.             ResetTrack(c);
  480.     
  481.     }
  482.     numTracks = n;
  483. }
  484.  
  485. int mi::MSToSamples(double const ms)
  486. {
  487.     return (int)(pMasterInfo->SamplesPerSec * ms * (1.0 / 1000.0));
  488. }
  489.  
  490. void mi::InitTrack(int const i)
  491. {
  492. }
  493.  
  494. void mi::ResetTrack(int const i)
  495. {
  496. }
  497.  
  498.  
  499. void mi::TickTrack(CTrack *pt, tvals *ptval)
  500. {
  501.     if (ptval->speed    !=    paraSpeed    .NoValue)
  502.         pt->Speed        =    (double)ptval -> speed;
  503.  
  504.     if (ptval->unit        !=    paraUnit    .NoValue)
  505.         pt->Unit        =            ptval -> unit;
  506.  
  507.     if (ptval->wave        !=    paraWave    .NoValue)
  508.         pt->Wave        =            ptval -> wave;
  509.  
  510.     if (ptval->wavepow    !=    paraWavePow    .NoValue)
  511.         pt->WavePow        =            ptval -> wavepow;
  512.  
  513.     if (ptval->floor    !=    paraFloor    .NoValue)
  514.         pt->Floor        =            ptval -> floor;
  515.  
  516.     if (ptval->spread    !=    paraSpread    .NoValue)
  517.         pt->Spread        =    (double)ptval -> spread    / (double)paraSpread.MaxValue * 2.0 - 1.0;
  518.  
  519.     if (ptval->slur        !=    paraSlur    .NoValue)
  520.         pt->Slur        =    (double)ptval -> slur    / (double)paraSlur.MaxValue;
  521.  
  522.     if (ptval->gain        !=    paraGain    .NoValue)
  523.         pt->Gain        =    (double)ptval -> gain    / (double)paraGain.DefValue;
  524.  
  525.     if (ptval->reset    !=    paraReset    .NoValue)
  526.         pt->Reset        =    (bool)    ptval -> reset;
  527. }
  528.  
  529. void mi::Tick()
  530. {
  531.     m_Tick++;
  532.  
  533.     for (int c = 0; c < numTracks; c++)
  534.         TickTrack(Tracks + c, tval+c);
  535. }
  536.  
  537.  
  538.  
  539. bool mi::WorkMonoToStereo(float *pin, float *pout, int numsamples, int const mode)
  540. {
  541.     if (mode != WM_READWRITE)
  542.         return false;
  543.  
  544.     int    i, inum;
  545.     int    j;
  546.     int    p, pnum;
  547.  
  548.     inum    =    numsamples;
  549.     j        =    0;
  550.  
  551.     int        op;
  552.     op        =    pos;
  553.     pos        +=    pMasterInfo ->    PosInTick - pos2;
  554.     pos2    =    pMasterInfo ->    PosInTick;
  555.  
  556.     double    f1;
  557.     double    f2;
  558.     double    SecondsPerSample;
  559.     double    floor;
  560.     double    one_minus_floor;
  561.     double    Spread;
  562.     double    Slur, OneMinusSlur;
  563.     double    Gain;
  564.  
  565.     floor                =    (double)(Tracks[0].Floor) / (double)paraFloor.MaxValue;
  566.     one_minus_floor        =    1.0 - floor;
  567.  
  568.     SecondsPerSample    =    1.0 / (double)pMasterInfo -> SamplesPerSec;
  569.     SecondsPerSample    *=    Tracks[0].GetFrequency(pMasterInfo);
  570.  
  571.     Spread                =    Tracks[0].Spread;
  572.  
  573.     pnum                =    Tracks[0].WavePow;
  574.  
  575.     Slur                =    Tracks[0].Slur;
  576.     OneMinusSlur        =    1.0 - Slur;
  577.  
  578.     Gain                =    Tracks[0].Gain;
  579.  
  580.     if (Tracks[0].Reset)
  581.         {
  582.         m_Second        =    0;
  583.         Tracks[0].Reset    =    false;
  584.         }
  585.  
  586.  
  587.     switch (Tracks[0].Wave)
  588.         {
  589.         default:
  590.         case    WAVE_SIN:
  591.             Spread            *=    PI * 0.5;
  592.             for (i = 0; i < inum; i++)
  593.                 {
  594.                 f1            =    sin(m_Second * PI * 2.0 - Spread) * 0.5 + 0.5;
  595.                 f2            =    sin(m_Second * PI * 2.0 + Spread) * 0.5 + 0.5;
  596.                 m_Second    +=    SecondsPerSample;
  597.                 // This prevents the math from overflowing.
  598.                 if (m_Second > 1.0)
  599.                     m_Second -= 1.0;
  600.  
  601.                 for (p = 1; p < pnum; p++)
  602.                     {
  603.                     f1        *=    f1;
  604.                     f2        *=    f2;
  605.                     }
  606.  
  607.                 f1            =    f1 * one_minus_floor + floor;
  608.                 f2            =    f2 * one_minus_floor + floor;
  609.  
  610.                 f1            *=    Gain;
  611.                 f2            *=    Gain;
  612.  
  613.                 f1            =    OneMinusSlur * f1 + Slur * m_PrevF1;
  614.                 f2            =    OneMinusSlur * f2 + Slur * m_PrevF2;
  615.                 m_PrevF1    =    f1;
  616.                 m_PrevF2    =    f2;
  617.  
  618.                 pout[j]        =    pin[i] * (float)f1;
  619.                 j++;
  620.                 pout[j]        =    pin[i] * (float)f2;
  621.                 j++;
  622.                 }
  623.             break;
  624.  
  625.         case    WAVE_SQUARE:
  626.             Spread            *=    0.25;
  627.             for (i = 0; i < inum; i++)
  628.                 {
  629.                 f1            =    m_Second - Spread + 0.25;
  630.                 if (f1 < 0.0)
  631.                     f1 += 1.0;
  632.                 else if (f1 > 1.0)
  633.                     f1 -= 1.0;
  634.                 f2            =    m_Second + Spread + 0.25;
  635.                 if (f2 < 0.0)
  636.                     f2 += 1.0;
  637.                 else if (f2 > 1.0)
  638.                     f2 -= 1.0;
  639.                 if (f1 < 0.5)
  640.                     f1    =    0.0;
  641.                 else
  642.                     f1    =    1.0;
  643.                 if (f2 < 0.5)
  644.                     f2    =    0.0;
  645.                 else
  646.                     f2    =    1.0;
  647.  
  648.                 m_Second    +=    SecondsPerSample;
  649.                 // This prevents the math from overflowing.
  650.                 if (m_Second > 1.0)
  651.                     m_Second -= 1.0;
  652.  
  653.                 f1            =    f1 * one_minus_floor + floor;
  654.                 f2            =    f2 * one_minus_floor + floor;
  655.  
  656.                 f1            *=    Gain;
  657.                 f2            *=    Gain;
  658.  
  659.                 f1            =    OneMinusSlur * f1 + Slur * m_PrevF1;
  660.                 f2            =    OneMinusSlur * f2 + Slur * m_PrevF2;
  661.                 m_PrevF1    =    f1;
  662.                 m_PrevF2    =    f2;
  663.  
  664.                 pout[j]        =    pin[i] * (float)f1;
  665.                 j++;
  666.                 pout[j]        =    pin[i] * (float)f2;
  667.                 j++;
  668.                 }
  669.             break;
  670.  
  671.         case    WAVE_TRIANGLE:
  672.             Spread            *=    0.25;
  673.             for (i = 0; i < inum; i++)
  674.                 {
  675.                 f1            =    m_Second - Spread + 0.25;
  676.                 if (f1 < 0.0)
  677.                     f1 += 1.0;
  678.                 else if (f1 > 1.0)
  679.                     f1 -= 1.0;
  680.                 f2            =    m_Second + Spread + 0.25;
  681.                 if (f2 < 0.0)
  682.                     f2 += 1.0;
  683.                 else if (f2 > 1.0)
  684.                     f2 -= 1.0;
  685.  
  686.                 f1    *=    2.0;
  687.                 f2    *=    2.0;
  688.  
  689.                 if (f1 > 1.0)
  690.                     f1    =    2.0 - f1;
  691.                 if (f2 > 1.0)
  692.                     f2    =    2.0 - f2;
  693.  
  694.                 m_Second    +=    SecondsPerSample;
  695.                 // This prevents the math from overflowing.
  696.                 if (m_Second > 1.0)
  697.                     m_Second -= 1.0;
  698.  
  699.                 for (p = 1; p < pnum; p++)
  700.                     {
  701.                     f1        *=    f1;
  702.                     f2        *=    f2;
  703.                     }
  704.  
  705.                 f1            =    f1 * one_minus_floor + floor;
  706.                 f2            =    f2 * one_minus_floor + floor;
  707.  
  708.                 f1            *=    Gain;
  709.                 f2            *=    Gain;
  710.  
  711.                 f1            =    OneMinusSlur * f1 + Slur * m_PrevF1;
  712.                 f2            =    OneMinusSlur * f2 + Slur * m_PrevF2;
  713.                 m_PrevF1    =    f1;
  714.                 m_PrevF2    =    f2;
  715.  
  716.                 pout[j]        =    pin[i] * (float)f1;
  717.                 j++;
  718.                 pout[j]        =    pin[i] * (float)f2;
  719.                 j++;
  720.                 }
  721.             break;
  722.  
  723.         case    WAVE_SAW:
  724.             Spread            *=    0.25;
  725.             for (i = 0; i < inum; i++)
  726.                 {
  727.                 f1            =    m_Second - Spread + 0.25;
  728.                 if (f1 < 0.0)
  729.                     f1 += 1.0;
  730.                 else if (f1 > 1.0)
  731.                     f1 -= 1.0;
  732.                 f2            =    m_Second + Spread + 0.25;
  733.                 if (f2 < 0.0)
  734.                     f2 += 1.0;
  735.                 else if (f2 > 1.0)
  736.                     f2 -= 1.0;
  737.  
  738.                 m_Second    +=    SecondsPerSample;
  739.                 // This prevents the math from overflowing.
  740.                 if (m_Second > 1.0)
  741.                     m_Second -= 1.0;
  742.  
  743.                 for (p = 1; p < pnum; p++)
  744.                     {
  745.                     f1        *=    f1;
  746.                     f2        *=    f2;
  747.                     }
  748.  
  749.                 f1            =    f1 * one_minus_floor + floor;
  750.                 f2            =    f2 * one_minus_floor + floor;
  751.  
  752.                 f1            *=    Gain;
  753.                 f2            *=    Gain;
  754.  
  755.                 f1            =    OneMinusSlur * f1 + Slur * m_PrevF1;
  756.                 f2            =    OneMinusSlur * f2 + Slur * m_PrevF2;
  757.                 m_PrevF1    =    f1;
  758.                 m_PrevF2    =    f2;
  759.  
  760.                 pout[j]        =    pin[i] * (float)f1;
  761.                 j++;
  762.                 pout[j]        =    pin[i] * (float)f2;
  763.                 j++;
  764.                 }
  765.             break;
  766.         case    WAVE_INVSAW:
  767.             Spread            *=    0.25;
  768.             for (i = 0; i < inum; i++)
  769.                 {
  770.                 f1            =    m_Second - Spread + 0.25;
  771.                 if (f1 < 0.0)
  772.                     f1 += 1.0;
  773.                 else if (f1 > 1.0)
  774.                     f1 -= 1.0;
  775.                 f2            =    m_Second + Spread + 0.25;
  776.                 if (f2 < 0.0)
  777.                     f2 += 1.0;
  778.                 else if (f2 > 1.0)
  779.                     f2 -= 1.0;
  780.  
  781.                 f1    =    1.0 - f1;
  782.                 f2    =    1.0 - f2;
  783.  
  784.                 m_Second    +=    SecondsPerSample;
  785.                 // This prevents the math from overflowing.
  786.                 if (m_Second > 1.0)
  787.                     m_Second -= 1.0;
  788.  
  789.                 for (p = 1; p < pnum; p++)
  790.                     {
  791.                     f1        *=    f1;
  792.                     f2        *=    f2;
  793.                     }
  794.  
  795.                 f1            =    f1 * one_minus_floor + floor;
  796.                 f2            =    f2 * one_minus_floor + floor;
  797.  
  798.                 f1            *=    Gain;
  799.                 f2            *=    Gain;
  800.  
  801.                 f1            =    OneMinusSlur * f1 + Slur * m_PrevF1;
  802.                 f2            =    OneMinusSlur * f2 + Slur * m_PrevF2;
  803.                 m_PrevF1    =    f1;
  804.                 m_PrevF2    =    f2;
  805.  
  806.                 pout[j]        =    pin[i] * (float)f1;
  807.                 j++;
  808.                 pout[j]        =    pin[i] * (float)f2;
  809.                 j++;
  810.                 }
  811.             break;
  812.         }
  813.  
  814.     return true;
  815. }
  816.